int[] (Groovy JDK enhancements)

Methods Summary

Methods
Return type	Name and parameters
`boolean`	`any(Closure predicate)` Iterates over the contents of an int Array, and checks whether a predicate is valid for at least one element.
`boolean`	`asBoolean()` Coerces an int array to a boolean value.
`BigDecimal`	`average()` Calculates the average of the ints in the array.
`List`	`chop(int chopSizes)` Chops the int array into pieces, returning lists with sizes corresponding to the supplied chop sizes.
`boolean`	`contains(Object value)` Checks whether the array contains the given value.
`Number`	`count(Object value)` Counts the number of occurrences of the given value inside this array.
`int[]`	`each(IntConsumer consumer)` Iterates through an int[] passing each int to the given consumer.
`int[]`	`eachWithIndex(Closure closure)` Iterates through an int[], passing each int and the element's index (a counter starting at zero) to the given closure.
`boolean`	`equals(int[] right)` Compares the contents of this array to the contents of the given array.
`boolean`	`every(Closure predicate)` Iterates over the contents of an int Array, and checks whether a predicate is valid for all elements.
`int`	`first()` Returns the first item from the int array.
`List`	`flatten()` Flattens an array.
`List`	`getAt(IntRange range)` Supports the subscript operator for an int array with an IntRange giving the desired indices.
`List`	`getAt(ObjectRange range)` Supports the subscript operator for an int array with an ObjectRange giving the desired indices.
`List`	`getAt(Range range)` Supports the subscript operator for an int array with a range giving the desired indices.
`List`	`getAt(Collection indices)` Supports the subscript operator for an int array with a (potentially nested) collection giving the desired indices.
`IntRange`	`getIndices()` Returns indices of the int array.
`int`	`head()` Returns the first item from the int array.
`Map`	`indexed()` Zips an int[] with indices in (index, value) order starting from index 0.
`Map`	`indexed(int offset)` Zips an int[] with indices in (index, value) order.
`int[]`	`init()` Returns the items from the int array excluding the last item.
`IntStream`	`intStream()` Returns a sequential IntStream with the specified array as its source.
`String`	`join()` Concatenates the string representation of each item in this array.
`String`	`join(String separator)` Concatenates the string representation of each item in this array, with the given String as a separator between each item.
`int`	`last()` Returns the last item from the int array.
`int`	`max()` Adds max() method to int arrays.
`int`	`max(IntComparator comparator)` Selects the maximum value found from the int array using the supplied IntComparator to determine the maximum of any two values.
`int`	`max(IntUnaryOperator operator)` Selects the maximum value found from the int array using the supplier IntUnaryOperator to determine the maximum of any two values.
`int`	`maxComparing(Comparator comparator)` Selects the maximum value found from the int array using the comparator to determine the maximum of any two values.
`int`	`min()` Adds min() method to int arrays.
`int`	`min(IntComparator comparator)` Selects the minimum value found from the int array using the supplier IntComparator to determine the minimum of any two values.
`int`	`min(IntUnaryOperator operator)` Selects the minimum value found from the int array using the supplier IntUnaryOperator to determine the minimum of any two values.
`int`	`minComparing(Comparator comparator)` Selects the minimum value found from the int array using the comparator to determine the minimum of any two values.
`int[]`	`reverse()` Creates a new int array containing items which are the same as this array but in reverse order.
`int[]`	`reverse(boolean mutate)` Reverses the items in an array.
`int[]`	`reverseEach(Closure closure)` Iterates through an int[] in reverse order passing each int to the given closure.
`int`	`size()` Provides arrays with a `size` method similar to collections.
`Stream`	`stream()` Returns a sequential Stream with the specified array as its source.
`int`	`sum()` Sums the items in an array.
`int`	`sum(int initialValue)` Sums the items in an array, adding the result to some initial value.
`int[]`	`swap(int i, int j)` Swaps two elements at the specified positions.
`int[]`	`tail()` Returns the items from the int array excluding the first item.
`List`	`toList()` Converts this array to a List of the same size, with each element added to the list.
`Set`	`toSet()` Converts this array to a Set, with each unique element added to the set.
`String`	`toString()` Returns the string representation of the given array.
`Iterator`	`zip(int[] other)` An iterator of all the pairs of two arrays.

- Methods Detail
  - public boolean any(Closure predicate)
    
    Iterates over the contents of an int Array, and checks whether a predicate is valid for at least one element.
```
int[] array = [0, 1, 2]
assert array.any{ it > 1 }
assert !array.any{ it > 3 }
```
    Parameters:
    
    predicate - the closure predicate used for matching
    
    Returns:
    
    true if any iteration for the ints matches the closure predicate
    
    Since:
    
    5.0.0
  - public boolean asBoolean()
    
    Coerces an int array to a boolean value. An int array is false if the array is of length 0, and true otherwise.
    
    Returns:
    
    the array's boolean value
    
    Since:
    
    1.7.4
  - public BigDecimal average()
    
    Calculates the average of the ints in the array.
```
assert 5.0G == ([2,4,6,8] as int[]).average()
```
    Returns:
    
    The average of the items
    
    Since:
    
    3.0.0
  - public List chop(int chopSizes)
    
    Chops the int array into pieces, returning lists with sizes corresponding to the supplied chop sizes. If the array isn't large enough, truncated (possibly empty) pieces are returned. Using a chop size of -1 will cause that piece to contain all remaining items from the array.
```
int[] array = [0, 1, 2]
assert array.chop(1, 2) == [[0], [1, 2]]
```
    Parameters:
    
    chopSizes - the sizes for the returned pieces
    
    Returns:
    
    a list of lists chopping the original array elements into pieces determined by chopSizes
    
    Since:
    
    5.0.0
    
    See Also:
    
    ArrayGroovyMethods#collate(Object[], int) to chop a list into pieces of a fixed size
  - public boolean contains(Object value)
    
    Checks whether the array contains the given value.
    
    Parameters:
    
    value - the value being searched for
    
    Returns:
    
    true if the array contains the value
    
    Since:
    
    1.8.6
  - public Number count(Object value)
    
    Counts the number of occurrences of the given value inside this array. Comparison is done using Groovy's == operator (using compareTo(value) == 0).
```
int[] array = [10, 20, 20, 30]
assert array.count(20) == 2
```
    Parameters:
    
    value - the value being searched for
    
    Returns:
    
    the number of occurrences
    
    Since:
    
    1.6.4
    
    See Also:
    
    DefaultGroovyMethods#count(Iterator, Object)
  - public int[] each(IntConsumer consumer)
    
    Iterates through an int[] passing each int to the given consumer.
```
int[] array = [0, 1, 2]
String result = ''
array.each{ result += it }
assert result == '012'
```
    Parameters:
    
    consumer - the consumer for each int
    
    Returns:
    
    the self array
    
    Since:
    
    5.0.0
  - public int[] eachWithIndex(Closure closure)
    
    Iterates through an int[], passing each int and the element's index (a counter starting at zero) to the given closure.
```
int[] array = [10, 20, 30]
String result = ''
array.eachWithIndex{ item, index -> result += "$index($item)" }
assert result == '0(10)1(20)2(30)'
```
    Parameters:
    
    closure - a Closure to operate on each int
    
    Returns:
    
    the self array
    
    Since:
    
    5.0.0
  - public boolean equals(int[] right)
    
    Compares the contents of this array to the contents of the given array.
    Example usage:
```
int[] array1 = [4, 8]
int[] array2 = [4, 8]
assert array1 !== array2
assert array1.equals(array2)
```
    Parameters:
    
    right - the array being compared
    
    Returns:
    
    true if the contents of both arrays are equal.
    
    Since:
    
    5.0.0
  - public boolean every(Closure predicate)
    
    Iterates over the contents of an int Array, and checks whether a predicate is valid for all elements.
```
int[] array = [0, 1, 2]
assert array.every{ it < 3 }
assert !array.every{ it > 1 }
```
    Parameters:
    
    predicate - the closure predicate used for matching
    
    Returns:
    
    true if the predicate returns true for all elements in the array
    
    Since:
    
    5.0.0
  - public int first()
    
    Returns the first item from the int array.
```
int[] ints = [1, 3, 5]
assert ints.first() == 1
```
    An alias for head().
    
    Returns:
    
    the first element
    
    Since:
    
    5.0.0
  - public List flatten()
    
    Flattens an array. This array is added to a new collection. It is an alias for toList() but allows algorithms to be written which also work on multidimensional arrays or non-arrays where flattening would be applicable.
```
int[] array = [0, 1]
assert array.flatten() == [0, 1]
```
    Returns:
    
    a Collection of the array elements
    
    Since:
    
    1.6.0
  - public List getAt(IntRange range)
    
    Supports the subscript operator for an int array with an IntRange giving the desired indices.
```
int[] array = [0, 10, 20, 30, 40]
assert array[2..3] == [20, 30]
assert array[-2..-1] == [30, 40]
assert array[-1..-2] == [40, 30]
```
    Parameters:
    
    range - an IntRange indicating the indices for the items to retrieve
    
    Returns:
    
    list of the retrieved ints
    
    Since:
    
    1.0
  - public List getAt(ObjectRange range)
    
    Supports the subscript operator for an int array with an ObjectRange giving the desired indices.
```
int[] array = [0, 10, 20, 30, 40]
def range = new ObjectRange(2, 3)
assert array[range] == [20, 30]
```
    Parameters:
    
    range - an ObjectRange indicating the indices for the items to retrieve
    
    Returns:
    
    list of the retrieved ints
    
    Since:
    
    1.0
  - public List getAt(Range range)
    
    Supports the subscript operator for an int array with a range giving the desired indices.
```
int[] array = [1, 3, 5, 7, 9, 11]
assert array[2..<2] == [] // EmptyRange
assert array[(0..5.5).step(2)] == [1, 5, 9]   // NumberRange
assert array[(1..5.5).step(2)] == [3, 7, 11]  // NumberRange
```
    Parameters:
    
    range - a range indicating the indices for the items to retrieve
    
    Returns:
    
    list of the ints at the given indices
    
    Since:
    
    1.0
  - public List getAt(Collection indices)
    
    Supports the subscript operator for an int array with a (potentially nested) collection giving the desired indices.
```
int[] array = [0, 2, 4, 6, 8]
assert array[2, 3] == [4, 6]
assert array[1, 0..1, [0, [-1]]] == [2, 0, 2, 0, 8]
```
    Parameters:
    
    indices - a collection of indices for the items to retrieve
    
    Returns:
    
    list of the ints at the given indices
    
    Since:
    
    1.0
  - public IntRange getIndices()
    
    Returns indices of the int array.
```
int[] array = [0, 1]
assert array.indices == 0..1
```
    Since:
    
    3.0.8
    
    See Also:
    
    ArrayGroovyMethods#getIndices(Object[])
  - public int head()
    
    Returns the first item from the int array.
```
int[] ints = [1, 3, 5]
assert ints.head() == 1
```
    An alias for first().
    
    Returns:
    
    the first element
    
    Since:
    
    5.0.0
  - public Map indexed()
    
    Zips an int[] with indices in (index, value) order starting from index 0.
    Example usage:
```
int[] nums = [10, 20, 30]
assert [0: 10, 1: 20, 2: 30] == nums.indexed()
```
    Since:
    
    3.0.8
    
    See Also:
    
    int[]#indexed(int)
  - public Map indexed(int offset)
    
    Zips an int[] with indices in (index, value) order.
    Example usage:
```
int[] nums = [10, 20, 30]
assert [5: 10, 6: 20, 7: 30] == nums.indexed(5)
assert ["1: 10", "2: 20", "3: 30"] == nums.indexed(1).collect { idx, str -> "$idx: $str" }
```
    Parameters:
    
    offset - an index to start from
    
    Returns:
    
    a Map (since the keys/indices are unique) containing the elements from the iterable zipped with indices
    
    Since:
    
    3.0.8
    
    See Also:
    
    DefaultGroovyMethods#indexed(Iterable, int)
  - public int[] init()
    
    Returns the items from the int array excluding the last item.
```
int[] ints = [1, 3, 5]
def result = ints.init()
assert result == [1, 3]
assert ints.class.componentType == result.class.componentType
```
    Returns:
    
    an array without its last element
    
    Since:
    
    5.0.0
  - public IntStream intStream()
    
    Returns a sequential IntStream with the specified array as its source.
    
    Returns:
    
    a Stream for the array
    
    Since:
    
    3.0.8
  - public String join()
    
    Concatenates the string representation of each item in this array.
    
    Returns:
    
    the joined String
    
    Since:
    
    5.0.0
  - public String join(String separator)
    
    Concatenates the string representation of each item in this array, with the given String as a separator between each item.
    
    Parameters:
    
    separator - a String separator
    
    Returns:
    
    the joined String
    
    Since:
    
    2.4.1
  - public int last()
    
    Returns the last item from the int array.
```
int[] ints = [1, 3, 5]
assert ints.last() == 5
```
    Returns:
    
    the last element
    
    Since:
    
    5.0.0
  - public int max()
    
    Adds max() method to int arrays.
    Example usage:
```
int[] nums = [1, 3, 2]
assert 3 == nums.max()
```
    Returns:
    
    the maximum value
    
    Since:
    
    3.0.8
  - public int max(IntComparator comparator)
    
    Selects the maximum value found from the int array using the supplied IntComparator to determine the maximum of any two values.
```
int[] nums = [10, 20, -30]
assert 20 == nums.max{ n, m -> n <=> m }
assert -30 == nums.max{ n, m -> n.abs() <=> m.abs() }
```
    Parameters:
    
    comparator - a comparator, i.e. returns a negative value if the first parameter is less than the second
    
    Returns:
    
    the maximum value
    
    Since:
    
    5.0.0
  - public int max(IntUnaryOperator operator)
    
    Selects the maximum value found from the int array using the supplier IntUnaryOperator to determine the maximum of any two values. The operator is applied to each array element and the results are compared.
```
int[] nums = [10, 20, -30]
assert 20 == nums.max{ it }
assert -30 == nums.max{ it.abs() }
```
    Parameters:
    
    operator - an operator that returns an int used for comparing values
    
    Returns:
    
    the maximum value
    
    Since:
    
    5.0.0
  - public int maxComparing(Comparator comparator)
    
    Selects the maximum value found from the int array using the comparator to determine the maximum of any two values.
```
int[] nums = [10, 20, 30]
assert 30 == nums.maxComparing(Comparator.naturalOrder())
assert 10 == nums.maxComparing(Comparator.reverseOrder())
```
    Parameters:
    
    comparator - a Comparator
    
    Returns:
    
    the maximum value
    
    Since:
    
    5.0.0
    
    See Also:
    
    DefaultGroovyMethods#max(Iterator, java.util.Comparator)
  - public int min()
    
    Adds min() method to int arrays.
    Example usage:
```
int[] nums = [20, 10, 30]
assert 10 == nums.min()
```
    Returns:
    
    the minimum value
    
    Since:
    
    3.0.8
  - public int min(IntComparator comparator)
    
    Selects the minimum value found from the int array using the supplier IntComparator to determine the minimum of any two values.
```
int[] nums = [10, -20, 30]
assert -20 == nums.min{ n, m -> n <=> m }
assert 10 == nums.min{ n, m -> n.abs() <=> m.abs() }
```
    Parameters:
    
    comparator - a comparator, i.e. returns a negative value if the first parameter is less than the second
    
    Returns:
    
    the minimum value
    
    Since:
    
    5.0.0
  - public int min(IntUnaryOperator operator)
    
    Selects the minimum value found from the int array using the supplier IntUnaryOperator to determine the minimum of any two values. The operator is applied to each array element and the results are compared.
```
int[] nums = [10, -20, 30]
assert -20L == nums.min{ n -> n }
assert 10L == nums.min{ n -> n.abs() }
```
    Parameters:
    
    operator - an operator that returns an int used for comparing values
    
    Returns:
    
    the minimum value
    
    Since:
    
    5.0.0
  - public int minComparing(Comparator comparator)
    
    Selects the minimum value found from the int array using the comparator to determine the minimum of any two values.
```
int[] nums = [1, 2, 3]
assert 1 == nums.minComparing(Comparator.naturalOrder())
assert 3 == nums.minComparing(Comparator.reverseOrder())
```
    Parameters:
    
    comparator - a Comparator
    
    Returns:
    
    the minimum value
    
    Since:
    
    5.0.0
    
    See Also:
    
    DefaultGroovyMethods#min(Iterator, java.util.Comparator)
  - public int[] reverse()
    
    Creates a new int array containing items which are the same as this array but in reverse order.
```
int[] array = 1..2
assert array.reverse() == 2..1
```
    Returns:
    
    an array containing the reversed items
    
    Since:
    
    5.0.0
    
    See Also:
    
    int[]#reverse(boolean)
  - public int[] reverse(boolean mutate)
    
    Reverses the items in an array. If mutate is true, the original array is modified in place and returned. Otherwise, a new array containing the reversed items is produced.
```
int[] array = 1..3
def yarra = array.reverse(true)
assert array == 3..1
assert yarra == 3..1
assert array === yarra
yarra = array.reverse(false)
assert array !== yarra
assert array == 3..1
assert yarra == 1..3
```
    Parameters:
    
    mutate - true if the array itself should be reversed in place, false if a new array should be created
    
    Returns:
    
    an array containing the reversed items
    
    Since:
    
    5.0.0
  - public int[] reverseEach(Closure closure)
    
    Iterates through an int[] in reverse order passing each int to the given closure.
```
int[] array = [0, 1, 2]
String result = ''
array.reverseEach{ result += it }
assert result == '210'
```
    Parameters:
    
    closure - the closure applied on each int
    
    Returns:
    
    the self array
    
    Since:
    
    5.0.0
  - public int size()
    
    Provides arrays with a size method similar to collections.
    
    Returns:
    
    the length of the array
    
    Since:
    
    1.0
  - public Stream stream()
    
    Returns a sequential Stream with the specified array as its source.
    
    Returns:
    
    a Stream for the array
    
    Since:
    
    2.5.0
  - public int sum()
    
    Sums the items in an array.
```
assert 1+2+3+4 == ([1,2,3,4] as int[]).sum()
```
    Returns:
    
    The sum of all the items
    
    Since:
    
    2.4.2
  - public int sum(int initialValue)
    
    Sums the items in an array, adding the result to some initial value.
```
assert 5+1+2+3+4 == ([1,2,3,4] as int[]).sum(5)
```
    Parameters:
    
    initialValue - the items in the array will be summed to this initial value
    
    Returns:
    
    The sum of all the items.
    
    Since:
    
    2.4.2
  - public int[] swap(int i, int j)
    
    Swaps two elements at the specified positions.
    Example:
```
assert ([1, 3, 2, 4] as int[]) == ([1, 2, 3, 4] as int[]).swap(1, 2)
```
    Parameters:
    
    i - a position
    
    j - a position
    
    Returns:
    
    self
    
    Since:
    
    2.4.0
  - public int[] tail()
    
    Returns the items from the int array excluding the first item.
```
int[] ints = [1, 3, 5]
def result = ints.tail()
assert result == [3, 5]
assert ints.class.componentType == result.class.componentType
```
    Returns:
    
    an array without its first element
    
    Since:
    
    5.0.0
  - public List toList()
    
    Converts this array to a List of the same size, with each element added to the list.
    
    Returns:
    
    A list containing the contents of this array.
    
    Since:
    
    1.0
  - public Set toSet()
    
    Converts this array to a Set, with each unique element added to the set.
```
int[] array = [1, 2, 3, 2, 1]
Set expected = [1, 2, 3]
assert array.toSet() == expected
```
    Returns:
    
    A set containing the unique contents of this array.
    
    Since:
    
    1.8.0
  - public String toString()
    
    Returns the string representation of the given array.
```
int[] array = [1, 2, 3, 2, 1]
assert array.toString() == '[1, 2, 3, 2, 1]'
```
    Returns:
    
    the string representation
    
    Since:
    
    1.6.0
  - public Iterator zip(int[] other)
    
    An iterator of all the pairs of two arrays.
```
int[] small = [1, 2, 3]
int[] large = [100, 200, 300]
assert [101, 202, 303] == small.zip(large).collect{ a, b -> a + b }
assert [small, large].transpose() == small.zip(large).toList()
```
    Parameters:
    
    other - another int[]
    
    Returns:
    
    an iterator of all the pairs from self and other

Class int[]

Methods Summary

Methods Detail

public boolean any(Closure predicate)

public boolean asBoolean()

public BigDecimal average()

public List chop(int chopSizes)

public boolean contains(Object value)

public Number count(Object value)

public int[] each(IntConsumer consumer)

public int[] eachWithIndex(Closure closure)

public boolean equals(int[] right)

public boolean every(Closure predicate)

public int first()

public List flatten()

public List getAt(IntRange range)

public List getAt(ObjectRange range)

public List getAt(Range range)

public List getAt(Collection indices)

public IntRange getIndices()

public int head()

public Map indexed()

public Map indexed(int offset)

public int[] init()

public IntStream intStream()

public String join()

public String join(String separator)

public int last()

public int max()

public int max(IntComparator comparator)

public int max(IntUnaryOperator operator)

public int maxComparing(Comparator comparator)

public int min()

public int min(IntComparator comparator)

public int min(IntUnaryOperator operator)

public int minComparing(Comparator comparator)

public int[] reverse()

public int[] reverse(boolean mutate)

public int[] reverseEach(Closure closure)

public int size()

public Stream stream()

public int sum()

public int sum(int initialValue)

public int[] swap(int i, int j)

public int[] tail()

public List toList()

public Set toSet()

public String toString()

public Iterator zip(int[] other)